Os computadores não compreendem linguagens de programação diretamente; elas precisam ser convertidas para a linguagem de máquina, composta apenas por 0s e 1s (binário), que é a única linguagem que o computador entende. Para converter um código em linguagem de máquina, dependendo da linguagem de programação, é usado um processo que pode ser de compilação ou de interpretação.
Linguagens de programação compiladas são aquelas em que o código-fonte é traduzido para código de máquina antes da execução do programa. Esse processo é realizado por um compilador, um programa que analisa o código-fonte e o converte em instruções diretamente compreensíveis pela arquitetura da máquina alvo. Essa tradução antecipada permite que o programa seja executado com eficiência e rapidez, uma vez que as instruções já foram processadas e otimizadas antes da execução.
Por outro lado, linguagens de programação interpretadas não são traduzidas para código de máquina antes da execução. Em vez disso, um interpretador analisa o código-fonte linha por linha durante a execução do programa. Isso significa que cada vez que o programa é executado, o interpretador deve analisar e traduzir novamente o código-fonte para instruções compreensíveis pela máquina. Embora esse processo possa ser mais lento em comparação com a compilação, as linguagens interpretadas oferecem maior portabilidade, pois o mesmo código-fonte pode ser executado em diferentes sistemas operacionais e arquiteturas, desde que haja um interpretador disponível para a linguagem em questão.
Algumas linguagens, como Python e JavaScript (JS), usam uma abordagem intermediária entre compilação e interpretação. Nesses casos, o código-fonte é primeiro compilado para um formato de baixo nível chamado bytecode (imagem: arquivo de texto para arquivo de bytecode). O bytecode é uma representação binária das instruções que a máquina virtual específica da linguagem pode entender. Em seguida, a máquina virtual, é responsável por executar esse bytecode. Dessa forma, o código-fonte é traduzido apenas uma vez para bytecode e depois pode ser executado por diferentes máquinas virtuais em diferentes plataformas, proporcionando a portabilidade das linguagens interpretadas sem a necessidade de interpretar o código-fonte linha por linha repetidamente.
Bytecodes permitem aplicar a técnica de compilação Just-In-Time (JIT). A compilação JIT ocorre em tempo de execução, isto é, durante a execução do bytecode, em vez de ser realizada antecipadamente, como na compilação tradicional. Durante a execução, um compilador JIT analisa o bytecode e traduz partes do código em código de máquina otimizado para a arquitetura específica do computador em que está sendo executado. Esse código de máquina é armazenado em cache para reutilização em futuras execuções do mesmo trecho de código, evitando a necessidade de recompilação repetitiva.
A execução de partes específicas do código otimizado em código de máquina pode melhorar significativamente o desempenho em comparação com a interpretação linha por linha ou a execução de bytecode não compilado para código de máquina. A compilação JIT também permite que a linguagem de programação forneça uma combinação de portabilidade e eficiência, pois o mesmo código-fonte pode ser executado em diferentes plataformas, mas o compilador JIT pode gerar código de máquina otimizado para cada plataforma específica.
Como as páginas web utilizam HTML+CSS+JavaScript, um bom navegador web moderno já vem com o interpretador de JavaScript instalado. Para executar códigos JavaScript, acesse as Ferramentas do Desenvolvedor do teu navegador web de preferência (na maioria dos navegadores, o atalho é a tecla F12), e abra a aba "Console". Esta aba é um terminal interativo, onde os comandos podem ser inseridos e executados um de cada vez.
Um Ambiente de Execução (Runtime Enviroment) é um kit com tudo que precisamos, como a máquina virtual e o compilador JIT, para desenvolver e executar aplicativos de uma determinada linguagem de programação. Para o JavaScript, instalaremos o ambiente de execução Node.js (node). Assim, conseguimos desenvolver e executar programas JavaScript sem a necessidade de um navegador web. O Node.js vem com o Node Package manager (npm), que é uma ferramenta que permite baixar, instalar e gerenciar pacotes de terceiros. Pacotes de terceiros são projetos desenvolvidos por outros desenvolvedores e que podem ser adicionados ao seu próprio projeto.
Siga os passos da seção correspondente ao teu sistema operacional, seja Linux ou Windows, a seguir:
Vamos instalar o Node Version Manager (nvm) e usá-lo para instalar o node e o npm. Recomendamos o uso de um gerenciador de versões, pois as versões mudam muito rapidamente. Você provavelmente precisará alternar entre várias versões do node com base nas necessidades dos diferentes projetos em que está trabalhando. O Node Version Manager (nvm) é um gerenciador de versões do node muito popular.
É sempre recomendável remover qualquer instalação existente do node ou npm antes de instalar um gerenciador de versões, pois diferentes tipos de instalação podem levar a conflitos.
wget -O - https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash.nvm --version. Deve aparecer a versão instalada do nvm, que, nesta data, é 0.39.7.nvm ls.nvm use node. Deve aparecer algo como "not yet installed".nvm install --lts.node --version. Verifique também se o npm foi instalado junto com o node: npm --version.nvm use v18.2.0. Lembrando que a versão deve estar instalada antes de mudar para ela. Para alterar para a última versão LTS: nvm use --lts.Siga uma das seguintes alternativas:
Opcional: O npm instala os pacotes por usuário. Se você estiver num computador com vários usuários usando o npm, vocês podem compartilhar a mesma pasta de pacotes e economizar espaço em disco.
Para isso, no Windows, se não tiver acesso administrativo, faça a alternativa 1. Se tiver acesso administrativo, faça a alternativa 2.
Alternativa 1
Execute os seguintes comandos no terminal:
npm -g set prefix %SYSTEMDRIVE%\npm
npm -g set cache %SYSTEMDRIVE%\npm-cache
$Path = [Environment]::GetEnvironmentVariable("PATH", "User")
[Environment]::SetEnvironmentVariable( "Path", "$Path;%SYSTEMDRIVE%\npm", "User" )
Esses comandos fazem: altera a localização da pasta onde os pacotes são instalados globalmente e a pasta cache para C:\npm e C:\npm-cache, adiciona a pasta C:\npm nas variáveis de ambiente do usuário.
Alternativa 2
Altere a localização da pasta onde os pacotes são instalados globalmente e da pasta cache, adicionando as seguintes configurações no arquivo C:\Program Files\nodejs\node_modules\npm\.npmrc:
prefix=C:\npm cache=C:\npm-cache
Adicione a pasta nas variáveis de ambiente do sistema, executando no terminal:
[Environment]::SetEnvironmentVariable("Path", "$Path;%SYSTEMDRIVE%\npm", "Machine")
ou
Para facilitar o desenvolvimento de programas em JavaScript, usaremos o Visual Studio Code (vscode). Trata-se de um Ambiente de Desenvolvimento Integrado (IDE) que integra recursos para escrever, depurar, compilar e gerenciar dependências de código em um único lugar. Você pode baixar o VSCode aqui.
Já com o JavaScript instalado, abra o vscode e acesse a aba de extensões (atalho Ctrl + Shift + X). Em seguida, instale as seguintes extensões:
É fundamental mantermos nosso ambiente de trabalho organizado. Como programadores, separamos nossos códigos em projetos, que são pastas que agrupam nossos arquivos de código.
Vamos baixar um projeto já configurado do GitHub. O GitHub é um site que hospeda repositórios Git, onde os desenvolvedores podem armazenar, compartilhar e colaborar em projetos. Você pode baixar e abrir o projeto de duas maneiras. Se você não tem o git instalado ou não está familiarizado com o git, siga as etapas da Alternativa 2. Se você tiver o git instalado, siga as etapas da Alternativa 1.
.zip. Descompacte o arquivo no local onde deseja armazenar seu projeto.De início, o projeto vem com dois arquivos de configuração. O arquivo .vscode/launch.json possui configurações do vscode para o projeto, como como compilá-lo e executá-lo. O arquivo package.json possui configurações do node para o projeto, como o nome dos autores do projeto, descrição do projeto, e pacotes de terceiros utilizados pelo projeto.
O projeto também vem com a pasta node_modules, onde ficam os pacotes de terceiros. No momento o único pacote que utilizaremos é o scanf, que nos auxilia a ler dados digitados pelo usuário.
Organizaremos nosso projeto por pastas. Criaremos uma pasta para cada capítulo, onde colocaremos os códigos desenvolvidos naquele capítulo. Como estamos no segundo capítulo, crie a pasta cap02 na pasta raiz do projeto. Você pode fazer isso no vscode clicando com o botão direito no espaço vazio da aba de explorador e selecionando "New folder...".
Agora, crie o arquivo hello-world.js dentro da pasta cap02. Você pode fazer isso no vscode clicando com o botão direito em cima da pasta cap02 e selecionando "New file...". Observe que todos os arquivos de código-fonte em JavaScript devem terminar com a extensão .js.
Escreva o código console.log('hello, world!') dentro do arquivo recém-criado. Para executar esse arquivo, abra o terminal na pasta raiz do projeto (atalho Ctrl+j) e execute node cap02/hello-world.js. Parabéns, esse é seu primeiro programa em JavaScript!
Você também pode executar qualquer arquivo .js aberto no vscode simplesmente teclando F5.
Errar faz parte do processo de aprendizagem, especialmente na programação. No entanto, às vezes é difícil encontrar a fonte de um erro no código. É aí que entra a arte de debugging. Debugging, ou depuração de código, é o processo de identificar, isolar e corrigir erros em um programa de computador. Quando um programa apresenta comportamentos inesperados, é necessário depurar o código para encontrar e resolver o problema. Isso envolve pausar a execução do programa, observar variáveis e valores em diferentes pontos do código e identificar onde ocorrem os erros. O debugging também é útil para entender o funcionamento do programa, permitindo que você o execute passo a passo, no seu próprio ritmo.
Crie o arquivo cap02/factorials.js com o seguinte código:
function calculateSumOfFactorials(argument1, argument2) {
let factorial1 = calculateFactorial(argument1);
let factorial2 = calculateFactorial(argument2);
let result = calculateSum(factorial1, factorial2);
return result;
}
function calculateFactorial(argument) {
let factorialResult = 1;
for (let i = 1; i <= argument; i++) {
factorialResult *= i;
}
return factorialResult;
}
function calculateSum(argument1, argument2) {
return argument1 + argument2;
}
let a = 5;
let b = 10;
let sumOfFactorials = calculateSumOfFactorials(a, b);
console.log("The sum of factorials of the entered integers is", sumOfFactorials);
(Observação: as barras em um caminho de arquivo significam as pastas onde o arquivo se encontra. Portanto, cap02/factorials.js significa que o arquivo factorials.js está dentro da pasta cap02).
Veja se você consegue entender o que esse código está fazendo. Agora, antes de executá-lo de uma vez, experimente colocar um breakpoint na linha 20.
Dentre as opções de depuração no vscode, você pode continuar a execução até o próximo breakpoint (F5), avançar (F10), entrar (F11), sair (Shift + F11).
Na aba de depuração, você pode ver os valores das variáveis atuais, definir observadores (watch) de variáveis ou expressões, consultar a pilha de chamadas de funções e os breakpoints.
Na aba "Debug Console", você pode escrever linhas de códigos que são executadas no contexto do programa atual, com acesso às suas variáveis e funções.
No momento, essas informações podem parecer abstratas se você ainda está no início de sua jornada como programador. No entanto, depurar é uma ferramenta essencial para programadores e, à medida que você aprender mais, tudo ficará mais claro e fará mais sentido. Por isso, convido você a revisitar essa seção após adquirir mais maturidade em programação. Com o tempo e o conhecimento adquirido, essas práticas e termos farão mais sentido e serão uma parte natural do teu fluxo de trabalho como desenvolvedor.
Anteriormente, vimos como baixar um projeto já configurado e pronto para uso. Aqui faremos o passo a passo para criar e configurar o projeto do zero.
.vscode/launch.json, adicione a linha "console": "integratedTerminal", logo acima da linha "type":"node",. Essa linha configura o vscode para executar os arquivos pelo terminal em vez do debug console, pois assim poderemos interagir com nossos programas.npm install -g pnpm.
pnpm init. É criado um arquivo package.json, que contém informações do teu projeto, como os pacotes que ele depende para ser executado.
Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser. Feche todos os terminais, reabra um terminal na pasta raiz do projeto e execute novamente pnpm init)."type": "module", no arquivo package.json.pnpm add scanf na pasta raiz do projeto. Ao instalar um pacote com o pnpm, o pacote é colocado na pasta node_modules e também registrado no arquivo package.json.cap02/input-output.js com o seguinte código:import scanf from 'scanf';
console.log('Please input your name');
let name = scanf('%s');
console.log('Please input your age');
let age = scanf('%d');
console.log('your name', name, 'is a', typeof name);
console.log('your age', age, 'is a', typeof age);
Não se preocupe em entender tudo o que está se passando. Esse capítulo é mais para deixar tudo preparado para começarmos a aprender JavaScript no próximo capítulo. Se este programa estiver funcionando conforme o esperado, ele vai te solicitar um nome e uma idade, e, depois que você informá-los, o programa responde com algumas mensagens.